/* 
 *  Syntelos XB
 *  Copyright (C) 2006 John Pritchard.
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 *  02111-1307 USA
 */

package syntelos.xb;


/**
 * <p> An {@link XB$XOP} operator. </p>
 * 
 * <p> JVM operators as found in the JCF are subclasses of this.  The
 * set here were produced by this writer (jdp) from the <i>Java
 * Virtual Machine Specification, Second Edition</i>, by Lindholm and
 * Yellin. </p>
 * 
 * @see syntelos.xb.Op$Constant
 * @see syntelos.xb.Op$Variable
 * @see syntelos.xb.Op$Branch
 * @see syntelos.xb.Op$Switch
 * @see syntelos.xb.op.Aaload
 * @see syntelos.xb.op.Nop
 * 
 * @author John Pritchard (jdp@syntelos.com)
 */
public abstract class Op
    extends Base
    implements java.lang.Cloneable,
               XB.XOP
{
    /**
     * Value op pc
     */
    protected final static syntelos.iou.dom.Name ATTRNAME_PC = new syntelos.iou.dom.impl.Name(STR_NIL,"pc");
    /**
     * Value op list index
     */
    protected final static syntelos.iou.dom.Name ATTRNAME_ID = new syntelos.iou.dom.impl.Name(STR_NIL,"id");
    /**
     * Value op source line number
     */
    protected final static syntelos.iou.dom.Name ATTRNAME_LNO = new syntelos.iou.dom.impl.Name(STR_NIL,"lno");



    protected final static byte ZED = (byte)0;
    /**
     * CF reader
     * 
     * @see #offset()
     */
    public interface Reader 
        extends java.io.DataInput
    {
        public final class Buffer 
            extends syntelos.iou.bbid
            implements Op.Reader
        {
            public Buffer(syntelos.iou.bbuf iobuffer){
                super(iobuffer);
            }
        }

        /**
         * @return Zero- positive offset from the start of the byte
         * code text segment for the last byte read.  Value negative
         * one before the first byte has been read.
         */
        public int offset();

        public int read() throws java.io.IOException;

        public int read(byte b[]) throws java.io.IOException;

        public int read(byte b[], int ofs, int len) throws java.io.IOException;

        public int available() throws java.io.IOException;

        public long skip(long n) throws java.io.IOException;

        public void close() throws java.io.IOException;

        public void mark(int m);

        public void reset() throws java.io.IOException;

        public boolean markSupported();

        public byte[] marked();
    }
    /**
     * CF writer
     * 
     * @see #offset()
     */
    public interface Writer
        extends java.io.DataOutput
    {
        public final class Buffer 
            extends syntelos.iou.bbod
            implements Op.Writer
        {
            public Buffer(syntelos.iou.bbuf iobuffer){
                super(iobuffer);
            }
        }

        /**
         * @return Zero- positive offset from the start of the byte
         * code text segment for the last byte written.  Value negative
         * one before the first byte has been written.
         */
        public int offset();

    }

    public final static int CODE_NOP 		 = 	 0x00;
    public final static int CODE_ACONST_NULL 	 = 	 0x01;
    public final static int CODE_ICONST_M1 	 = 	 0x02;
    public final static int CODE_ICONST_0 	 = 	 0x03;
    public final static int CODE_ICONST_1 	 = 	 0x04;
    public final static int CODE_ICONST_2 	 = 	 0x05;
    public final static int CODE_ICONST_3 	 = 	 0x06;
    public final static int CODE_ICONST_4 	 = 	 0x07;
    public final static int CODE_ICONST_5 	 = 	 0x08;
    public final static int CODE_LCONST_0 	 = 	 0x09;
    public final static int CODE_LCONST_1 	 = 	 0x0a;
    public final static int CODE_FCONST_0 	 = 	 0x0b;
    public final static int CODE_FCONST_1 	 = 	 0x0c;
    public final static int CODE_FCONST_2 	 = 	 0x0d;
    public final static int CODE_DCONST_0 	 = 	 0x0e;
    public final static int CODE_DCONST_1 	 = 	 0x0f;
    public final static int CODE_BIPUSH 	 = 	 0x10;
    public final static int CODE_SIPUSH 	 = 	 0x11;
    public final static int CODE_LDC 		 = 	 0x12;
    public final static int CODE_LDC_W 		 = 	 0x13;
    public final static int CODE_LDC2_W 	 = 	 0x14;
    public final static int CODE_ILOAD 		 = 	 0x15;
    public final static int CODE_LLOAD 		 = 	 0x16;
    public final static int CODE_FLOAD 		 = 	 0x17;
    public final static int CODE_DLOAD 		 = 	 0x18;
    public final static int CODE_ALOAD 		 = 	 0x19;
    public final static int CODE_ILOAD_0 	 = 	 0x1a;
    public final static int CODE_ILOAD_1 	 = 	 0x1b;
    public final static int CODE_ILOAD_2 	 = 	 0x1c;
    public final static int CODE_ILOAD_3 	 = 	 0x1d;
    public final static int CODE_LLOAD_0 	 = 	 0x1e;
    public final static int CODE_LLOAD_1 	 = 	 0x1f;
    public final static int CODE_LLOAD_2 	 = 	 0x20;
    public final static int CODE_LLOAD_3 	 = 	 0x21;
    public final static int CODE_FLOAD_0 	 = 	 0x22;
    public final static int CODE_FLOAD_1 	 = 	 0x23;
    public final static int CODE_FLOAD_2 	 = 	 0x24;
    public final static int CODE_FLOAD_3 	 = 	 0x25;
    public final static int CODE_DLOAD_0 	 = 	 0x26;
    public final static int CODE_DLOAD_1 	 = 	 0x27;
    public final static int CODE_DLOAD_2 	 = 	 0x28;
    public final static int CODE_DLOAD_3 	 = 	 0x29;
    public final static int CODE_ALOAD_0 	 = 	 0x2a;
    public final static int CODE_ALOAD_1 	 = 	 0x2b;
    public final static int CODE_ALOAD_2 	 = 	 0x2c;
    public final static int CODE_ALOAD_3 	 = 	 0x2d;
    public final static int CODE_IALOAD 	 = 	 0x2e;
    public final static int CODE_LALOAD 	 = 	 0x2f;
    public final static int CODE_FALOAD 	 = 	 0x30;
    public final static int CODE_DALOAD 	 = 	 0x31;
    public final static int CODE_AALOAD 	 = 	 0x32;
    public final static int CODE_BALOAD 	 = 	 0x33;
    public final static int CODE_CALOAD 	 = 	 0x34;
    public final static int CODE_SALOAD 	 = 	 0x35;
    public final static int CODE_ISTORE 	 = 	 0x36;
    public final static int CODE_LSTORE 	 = 	 0x37;
    public final static int CODE_FSTORE 	 = 	 0x38;
    public final static int CODE_DSTORE 	 = 	 0x39;
    public final static int CODE_ASTORE 	 = 	 0x3a;
    public final static int CODE_ISTORE_0 	 = 	 0x3b;
    public final static int CODE_ISTORE_1 	 = 	 0x3c;
    public final static int CODE_ISTORE_2 	 = 	 0x3d;
    public final static int CODE_ISTORE_3 	 = 	 0x3e;
    public final static int CODE_LSTORE_0 	 = 	 0x3f;
    public final static int CODE_LSTORE_1 	 = 	 0x40;
    public final static int CODE_LSTORE_2 	 = 	 0x41;
    public final static int CODE_LSTORE_3 	 = 	 0x42;
    public final static int CODE_FSTORE_0 	 = 	 0x43;
    public final static int CODE_FSTORE_1 	 = 	 0x44;
    public final static int CODE_FSTORE_2 	 = 	 0x45;
    public final static int CODE_FSTORE_3 	 = 	 0x46;
    public final static int CODE_DSTORE_0 	 = 	 0x47;
    public final static int CODE_DSTORE_1 	 = 	 0x48;
    public final static int CODE_DSTORE_2 	 = 	 0x49;
    public final static int CODE_DSTORE_3 	 = 	 0x4a;
    public final static int CODE_ASTORE_0 	 = 	 0x4b;
    public final static int CODE_ASTORE_1 	 = 	 0x4c;
    public final static int CODE_ASTORE_2 	 = 	 0x4d;
    public final static int CODE_ASTORE_3 	 = 	 0x4e;
    public final static int CODE_IASTORE 	 = 	 0x4f;
    public final static int CODE_LASTORE 	 = 	 0x50;
    public final static int CODE_FASTORE 	 = 	 0x51;
    public final static int CODE_DASTORE 	 = 	 0x52;
    public final static int CODE_AASTORE 	 = 	 0x53;
    public final static int CODE_BASTORE 	 = 	 0x54;
    public final static int CODE_CASTORE 	 = 	 0x55;
    public final static int CODE_SASTORE 	 = 	 0x56;
    public final static int CODE_POP 		 = 	 0x57;
    public final static int CODE_POP2 		 = 	 0x58;
    public final static int CODE_DUP 		 = 	 0x59;
    public final static int CODE_DUP_X1 	 = 	 0x5a;
    public final static int CODE_DUP_X2 	 = 	 0x5b;
    public final static int CODE_DUP2 		 = 	 0x5c;
    public final static int CODE_DUP2_X1 	 = 	 0x5d;
    public final static int CODE_DUP2_X2 	 = 	 0x5e;
    public final static int CODE_SWAP 		 = 	 0x5f;
    public final static int CODE_IADD 		 = 	 0x60;
    public final static int CODE_LADD 		 = 	 0x61;
    public final static int CODE_FADD 		 = 	 0x62;
    public final static int CODE_DADD 		 = 	 0x63;
    public final static int CODE_ISUB 		 = 	 0x64;
    public final static int CODE_LSUB 		 = 	 0x65;
    public final static int CODE_FSUB 		 = 	 0x66;
    public final static int CODE_DSUB 		 = 	 0x67;
    public final static int CODE_IMUL 		 = 	 0x68;
    public final static int CODE_LMUL 		 = 	 0x69;
    public final static int CODE_FMUL 		 = 	 0x6a;
    public final static int CODE_DMUL 		 = 	 0x6b;
    public final static int CODE_IDIV 		 = 	 0x6c;
    public final static int CODE_LDIV 		 = 	 0x6d;
    public final static int CODE_FDIV 		 = 	 0x6e;
    public final static int CODE_DDIV 		 = 	 0x6f;
    public final static int CODE_IREM 		 = 	 0x70;
    public final static int CODE_LREM 		 = 	 0x71;
    public final static int CODE_FREM 		 = 	 0x72;
    public final static int CODE_DREM 		 = 	 0x73;
    public final static int CODE_INEG 		 = 	 0x74;
    public final static int CODE_LNEG 		 = 	 0x75;
    public final static int CODE_FNEG 		 = 	 0x76;
    public final static int CODE_DNEG 		 = 	 0x77;
    public final static int CODE_ISHL 		 = 	 0x78;
    public final static int CODE_LSHL 		 = 	 0x79;
    public final static int CODE_ISHR 		 = 	 0x7a;
    public final static int CODE_LSHR 		 = 	 0x7b;
    public final static int CODE_IUSHR 		 = 	 0x7c;
    public final static int CODE_LUSHR 		 = 	 0x7d;
    public final static int CODE_IAND 		 = 	 0x7e;
    public final static int CODE_LAND 		 = 	 0x7f;
    public final static int CODE_IOR 		 = 	 0x80;
    public final static int CODE_LOR 		 = 	 0x81;
    public final static int CODE_IXOR 		 = 	 0x82;
    public final static int CODE_LXOR 		 = 	 0x83;
    public final static int CODE_IINC 		 = 	 0x84;
    public final static int CODE_I2L 		 = 	 0x85;
    public final static int CODE_I2F 		 = 	 0x86;
    public final static int CODE_I2D 		 = 	 0x87;
    public final static int CODE_L2I 		 = 	 0x88;
    public final static int CODE_L2F 		 = 	 0x89;
    public final static int CODE_L2D 		 = 	 0x8a;
    public final static int CODE_F2I 		 = 	 0x8b;
    public final static int CODE_F2L 		 = 	 0x8c;
    public final static int CODE_F2D 		 = 	 0x8d;
    public final static int CODE_D2I 		 = 	 0x8e;
    public final static int CODE_D2L 		 = 	 0x8f;
    public final static int CODE_D2F 		 = 	 0x90;
    public final static int CODE_I2B 		 = 	 0x91;
    public final static int CODE_I2C 		 = 	 0x92;
    public final static int CODE_I2S 		 = 	 0x93;
    public final static int CODE_LCMP 		 = 	 0x94;
    public final static int CODE_FCMPL 		 = 	 0x95;
    public final static int CODE_FCMPG 		 = 	 0x96;
    public final static int CODE_DCMPL 		 = 	 0x97;
    public final static int CODE_DCMPG 		 = 	 0x98;
    public final static int CODE_IFEQ 		 = 	 0x99;
    public final static int CODE_IFNE 		 = 	 0x9a;
    public final static int CODE_IFLT 		 = 	 0x9b;
    public final static int CODE_IFGE 		 = 	 0x9c;
    public final static int CODE_IFGT 		 = 	 0x9d;
    public final static int CODE_IFLE 		 = 	 0x9e;
    public final static int CODE_IF_ICMPEQ 	 = 	 0x9f;
    public final static int CODE_IF_ICMPNE 	 = 	 0xa0;
    public final static int CODE_IF_ICMPLT 	 = 	 0xa1;
    public final static int CODE_IF_ICMPGE 	 = 	 0xa2;
    public final static int CODE_IF_ICMPGT 	 = 	 0xa3;
    public final static int CODE_IF_ICMPLE 	 = 	 0xa4;
    public final static int CODE_IF_ACMPEQ 	 = 	 0xa5;
    public final static int CODE_IF_ACMPNE 	 = 	 0xa6;
    public final static int CODE_GOTO 		 = 	 0xa7;
    public final static int CODE_JSR 		 = 	 0xa8;
    public final static int CODE_RET 		 = 	 0xa9;
    public final static int CODE_TABLESWITCH 	 = 	 0xaa;
    public final static int CODE_LOOKUPSWITCH 	 = 	 0xab;
    public final static int CODE_IRETURN 	 = 	 0xac;
    public final static int CODE_LRETURN 	 = 	 0xad;
    public final static int CODE_FRETURN 	 = 	 0xae;
    public final static int CODE_DRETURN 	 = 	 0xaf;
    public final static int CODE_ARETURN 	 = 	 0xb0;
    public final static int CODE_RETURN 	 = 	 0xb1;
    public final static int CODE_GETSTATIC 	 = 	 0xb2;
    public final static int CODE_PUTSTATIC 	 = 	 0xb3;
    public final static int CODE_GETFIELD 	 = 	 0xb4;
    public final static int CODE_PUTFIELD 	 = 	 0xb5;
    public final static int CODE_INVOKEVIRTUAL 	 = 	 0xb6;
    public final static int CODE_INVOKESPECIAL 	 = 	 0xb7;
    public final static int CODE_INVOKESTATIC 	 = 	 0xb8;
    public final static int CODE_INVOKEINTERFACE = 	 0xb9;
    public final static int CODE_NEW 		 = 	 0xbb;
    public final static int CODE_NEWARRAY 	 = 	 0xbc;
    public final static int CODE_ANEWARRAY 	 = 	 0xbd;
    public final static int CODE_ARRAYLENGTH 	 = 	 0xbe;
    public final static int CODE_ATHROW 	 = 	 0xbf;
    public final static int CODE_CHECKCAST 	 = 	 0xc0;
    public final static int CODE_INSTANCEOF 	 = 	 0xc1;
    public final static int CODE_MONITORENTER 	 = 	 0xc2;
    public final static int CODE_MONITOREXIT 	 = 	 0xc3;
    public final static int CODE_WIDE 		 = 	 0xc4;
    public final static int CODE_MULTIANEWARRAY  = 	 0xc5;
    public final static int CODE_IFNULL 	 = 	 0xc6;
    public final static int CODE_IFNONNULL 	 = 	 0xc7;
    public final static int CODE_GOTO_W 	 = 	 0xc8;
    public final static int CODE_JSR_W 		 = 	 0xc9;

    private final static syntelos.iou.objmap dict = new syntelos.iou.objmap();
    static {
        dict.put(syntelos.xb.op.Aaload.name,new syntelos.xb.op.Aaload(true));
        dict.put(syntelos.xb.op.Aastore.name,new syntelos.xb.op.Aastore(true));
        dict.put(syntelos.xb.op.AconstNull.name,new syntelos.xb.op.AconstNull(true));
        dict.put(syntelos.xb.op.Aload0.name,new syntelos.xb.op.Aload0(true));
        dict.put(syntelos.xb.op.Aload1.name,new syntelos.xb.op.Aload1(true));
        dict.put(syntelos.xb.op.Aload2.name,new syntelos.xb.op.Aload2(true));
        dict.put(syntelos.xb.op.Aload3.name,new syntelos.xb.op.Aload3(true));
        dict.put(syntelos.xb.op.Aload.name,new syntelos.xb.op.Aload(true));
        dict.put(syntelos.xb.op.Anewarray.name,new syntelos.xb.op.Anewarray(true));
        dict.put(syntelos.xb.op.Areturn.name,new syntelos.xb.op.Areturn(true));
        dict.put(syntelos.xb.op.Arraylength.name,new syntelos.xb.op.Arraylength(true));
        dict.put(syntelos.xb.op.Astore0.name,new syntelos.xb.op.Astore0(true));
        dict.put(syntelos.xb.op.Astore1.name,new syntelos.xb.op.Astore1(true));
        dict.put(syntelos.xb.op.Astore2.name,new syntelos.xb.op.Astore2(true));
        dict.put(syntelos.xb.op.Astore3.name,new syntelos.xb.op.Astore3(true));
        dict.put(syntelos.xb.op.Astore.name,new syntelos.xb.op.Astore(true));
        dict.put(syntelos.xb.op.Athrow.name,new syntelos.xb.op.Athrow(true));
        dict.put(syntelos.xb.op.Baload.name,new syntelos.xb.op.Baload(true));
        dict.put(syntelos.xb.op.Bastore.name,new syntelos.xb.op.Bastore(true));
        dict.put(syntelos.xb.op.Bipush.name,new syntelos.xb.op.Bipush(true));
        dict.put(syntelos.xb.op.Caload.name,new syntelos.xb.op.Caload(true));
        dict.put(syntelos.xb.op.Castore.name,new syntelos.xb.op.Castore(true));
        dict.put(syntelos.xb.op.Checkcast.name,new syntelos.xb.op.Checkcast(true));
        dict.put(syntelos.xb.op.D2f.name,new syntelos.xb.op.D2f(true));
        dict.put(syntelos.xb.op.D2i.name,new syntelos.xb.op.D2i(true));
        dict.put(syntelos.xb.op.D2l.name,new syntelos.xb.op.D2l(true));
        dict.put(syntelos.xb.op.Dadd.name,new syntelos.xb.op.Dadd(true));
        dict.put(syntelos.xb.op.Daload.name,new syntelos.xb.op.Daload(true));
        dict.put(syntelos.xb.op.Dastore.name,new syntelos.xb.op.Dastore(true));
        dict.put(syntelos.xb.op.Dcmpg.name,new syntelos.xb.op.Dcmpg(true));
        dict.put(syntelos.xb.op.Dcmpl.name,new syntelos.xb.op.Dcmpl(true));
        dict.put(syntelos.xb.op.Dconst0.name,new syntelos.xb.op.Dconst0(true));
        dict.put(syntelos.xb.op.Dconst1.name,new syntelos.xb.op.Dconst1(true));
        dict.put(syntelos.xb.op.Ddiv.name,new syntelos.xb.op.Ddiv(true));
        dict.put(syntelos.xb.op.Dload0.name,new syntelos.xb.op.Dload0(true));
        dict.put(syntelos.xb.op.Dload1.name,new syntelos.xb.op.Dload1(true));
        dict.put(syntelos.xb.op.Dload2.name,new syntelos.xb.op.Dload2(true));
        dict.put(syntelos.xb.op.Dload3.name,new syntelos.xb.op.Dload3(true));
        dict.put(syntelos.xb.op.Dload.name,new syntelos.xb.op.Dload(true));
        dict.put(syntelos.xb.op.Dmul.name,new syntelos.xb.op.Dmul(true));
        dict.put(syntelos.xb.op.Dneg.name,new syntelos.xb.op.Dneg(true));
        dict.put(syntelos.xb.op.Drem.name,new syntelos.xb.op.Drem(true));
        dict.put(syntelos.xb.op.Dreturn.name,new syntelos.xb.op.Dreturn(true));
        dict.put(syntelos.xb.op.Dstore0.name,new syntelos.xb.op.Dstore0(true));
        dict.put(syntelos.xb.op.Dstore1.name,new syntelos.xb.op.Dstore1(true));
        dict.put(syntelos.xb.op.Dstore2.name,new syntelos.xb.op.Dstore2(true));
        dict.put(syntelos.xb.op.Dstore3.name,new syntelos.xb.op.Dstore3(true));
        dict.put(syntelos.xb.op.Dstore.name,new syntelos.xb.op.Dstore(true));
        dict.put(syntelos.xb.op.Dsub.name,new syntelos.xb.op.Dsub(true));
        dict.put(syntelos.xb.op.Dup2X1.name,new syntelos.xb.op.Dup2X1(true));
        dict.put(syntelos.xb.op.Dup2X2.name,new syntelos.xb.op.Dup2X2(true));
        dict.put(syntelos.xb.op.DupX1.name,new syntelos.xb.op.DupX1(true));
        dict.put(syntelos.xb.op.DupX2.name,new syntelos.xb.op.DupX2(true));
        dict.put(syntelos.xb.op.Dup2.name,new syntelos.xb.op.Dup2(true));
        dict.put(syntelos.xb.op.Dup.name,new syntelos.xb.op.Dup(true));
        dict.put(syntelos.xb.op.F2d.name,new syntelos.xb.op.F2d(true));
        dict.put(syntelos.xb.op.F2i.name,new syntelos.xb.op.F2i(true));
        dict.put(syntelos.xb.op.F2l.name,new syntelos.xb.op.F2l(true));
        dict.put(syntelos.xb.op.Fadd.name,new syntelos.xb.op.Fadd(true));
        dict.put(syntelos.xb.op.Faload.name,new syntelos.xb.op.Faload(true));
        dict.put(syntelos.xb.op.Fastore.name,new syntelos.xb.op.Fastore(true));
        dict.put(syntelos.xb.op.Fcmpg.name,new syntelos.xb.op.Fcmpg(true));
        dict.put(syntelos.xb.op.Fcmpl.name,new syntelos.xb.op.Fcmpl(true));
        dict.put(syntelos.xb.op.Fconst0.name,new syntelos.xb.op.Fconst0(true));
        dict.put(syntelos.xb.op.Fconst1.name,new syntelos.xb.op.Fconst1(true));
        dict.put(syntelos.xb.op.Fconst2.name,new syntelos.xb.op.Fconst2(true));
        dict.put(syntelos.xb.op.Fdiv.name,new syntelos.xb.op.Fdiv(true));
        dict.put(syntelos.xb.op.Fload0.name,new syntelos.xb.op.Fload0(true));
        dict.put(syntelos.xb.op.Fload1.name,new syntelos.xb.op.Fload1(true));
        dict.put(syntelos.xb.op.Fload2.name,new syntelos.xb.op.Fload2(true));
        dict.put(syntelos.xb.op.Fload3.name,new syntelos.xb.op.Fload3(true));
        dict.put(syntelos.xb.op.Fload.name,new syntelos.xb.op.Fload(true));
        dict.put(syntelos.xb.op.Fmul.name,new syntelos.xb.op.Fmul(true));
        dict.put(syntelos.xb.op.Fneg.name,new syntelos.xb.op.Fneg(true));
        dict.put(syntelos.xb.op.Frem.name,new syntelos.xb.op.Frem(true));
        dict.put(syntelos.xb.op.Freturn.name,new syntelos.xb.op.Freturn(true));
        dict.put(syntelos.xb.op.Fstore0.name,new syntelos.xb.op.Fstore0(true));
        dict.put(syntelos.xb.op.Fstore1.name,new syntelos.xb.op.Fstore1(true));
        dict.put(syntelos.xb.op.Fstore2.name,new syntelos.xb.op.Fstore2(true));
        dict.put(syntelos.xb.op.Fstore3.name,new syntelos.xb.op.Fstore3(true));
        dict.put(syntelos.xb.op.Fstore.name,new syntelos.xb.op.Fstore(true));
        dict.put(syntelos.xb.op.Fsub.name,new syntelos.xb.op.Fsub(true));
        dict.put(syntelos.xb.op.Getfield.name,new syntelos.xb.op.Getfield(true));
        dict.put(syntelos.xb.op.Getstatic.name,new syntelos.xb.op.Getstatic(true));
        dict.put(syntelos.xb.op.GotoW.name,new syntelos.xb.op.GotoW(true));
        dict.put(syntelos.xb.op.Goto.name,new syntelos.xb.op.Goto(true));
        dict.put(syntelos.xb.op.I2b.name,new syntelos.xb.op.I2b(true));
        dict.put(syntelos.xb.op.I2c.name,new syntelos.xb.op.I2c(true));
        dict.put(syntelos.xb.op.I2d.name,new syntelos.xb.op.I2d(true));
        dict.put(syntelos.xb.op.I2f.name,new syntelos.xb.op.I2f(true));
        dict.put(syntelos.xb.op.I2l.name,new syntelos.xb.op.I2l(true));
        dict.put(syntelos.xb.op.I2s.name,new syntelos.xb.op.I2s(true));
        dict.put(syntelos.xb.op.Iadd.name,new syntelos.xb.op.Iadd(true));
        dict.put(syntelos.xb.op.Iaload.name,new syntelos.xb.op.Iaload(true));
        dict.put(syntelos.xb.op.Iand.name,new syntelos.xb.op.Iand(true));
        dict.put(syntelos.xb.op.Iastore.name,new syntelos.xb.op.Iastore(true));
        dict.put(syntelos.xb.op.Iconst0.name,new syntelos.xb.op.Iconst0(true));
        dict.put(syntelos.xb.op.Iconst1.name,new syntelos.xb.op.Iconst1(true));
        dict.put(syntelos.xb.op.Iconst2.name,new syntelos.xb.op.Iconst2(true));
        dict.put(syntelos.xb.op.Iconst3.name,new syntelos.xb.op.Iconst3(true));
        dict.put(syntelos.xb.op.Iconst4.name,new syntelos.xb.op.Iconst4(true));
        dict.put(syntelos.xb.op.Iconst5.name,new syntelos.xb.op.Iconst5(true));
        dict.put(syntelos.xb.op.IconstM1.name,new syntelos.xb.op.IconstM1(true));
        dict.put(syntelos.xb.op.Idiv.name,new syntelos.xb.op.Idiv(true));
        dict.put(syntelos.xb.op.IfAcmpeq.name,new syntelos.xb.op.IfAcmpeq(true));
        dict.put(syntelos.xb.op.IfAcmpne.name,new syntelos.xb.op.IfAcmpne(true));
        dict.put(syntelos.xb.op.IfIcmpeq.name,new syntelos.xb.op.IfIcmpeq(true));
        dict.put(syntelos.xb.op.IfIcmpge.name,new syntelos.xb.op.IfIcmpge(true));
        dict.put(syntelos.xb.op.IfIcmpgt.name,new syntelos.xb.op.IfIcmpgt(true));
        dict.put(syntelos.xb.op.IfIcmple.name,new syntelos.xb.op.IfIcmple(true));
        dict.put(syntelos.xb.op.IfIcmplt.name,new syntelos.xb.op.IfIcmplt(true));
        dict.put(syntelos.xb.op.IfIcmpne.name,new syntelos.xb.op.IfIcmpne(true));
        dict.put(syntelos.xb.op.Ifeq.name,new syntelos.xb.op.Ifeq(true));
        dict.put(syntelos.xb.op.Ifge.name,new syntelos.xb.op.Ifge(true));
        dict.put(syntelos.xb.op.Ifgt.name,new syntelos.xb.op.Ifgt(true));
        dict.put(syntelos.xb.op.Ifle.name,new syntelos.xb.op.Ifle(true));
        dict.put(syntelos.xb.op.Iflt.name,new syntelos.xb.op.Iflt(true));
        dict.put(syntelos.xb.op.Ifne.name,new syntelos.xb.op.Ifne(true));
        dict.put(syntelos.xb.op.Ifnonnull.name,new syntelos.xb.op.Ifnonnull(true));
        dict.put(syntelos.xb.op.Ifnull.name,new syntelos.xb.op.Ifnull(true));
        dict.put(syntelos.xb.op.Iinc.name,new syntelos.xb.op.Iinc(true));
        dict.put(syntelos.xb.op.Iload0.name,new syntelos.xb.op.Iload0(true));
        dict.put(syntelos.xb.op.Iload1.name,new syntelos.xb.op.Iload1(true));
        dict.put(syntelos.xb.op.Iload2.name,new syntelos.xb.op.Iload2(true));
        dict.put(syntelos.xb.op.Iload3.name,new syntelos.xb.op.Iload3(true));
        dict.put(syntelos.xb.op.Iload.name,new syntelos.xb.op.Iload(true));
        dict.put(syntelos.xb.op.Imul.name,new syntelos.xb.op.Imul(true));
        dict.put(syntelos.xb.op.Ineg.name,new syntelos.xb.op.Ineg(true));
        dict.put(syntelos.xb.op.Instanceof.name,new syntelos.xb.op.Instanceof(true));
        dict.put(syntelos.xb.op.Invokeinterface.name,new syntelos.xb.op.Invokeinterface(true));
        dict.put(syntelos.xb.op.Invokespecial.name,new syntelos.xb.op.Invokespecial(true));
        dict.put(syntelos.xb.op.Invokestatic.name,new syntelos.xb.op.Invokestatic(true));
        dict.put(syntelos.xb.op.Invokevirtual.name,new syntelos.xb.op.Invokevirtual(true));
        dict.put(syntelos.xb.op.Ior.name,new syntelos.xb.op.Ior(true));
        dict.put(syntelos.xb.op.Irem.name,new syntelos.xb.op.Irem(true));
        dict.put(syntelos.xb.op.Ireturn.name,new syntelos.xb.op.Ireturn(true));
        dict.put(syntelos.xb.op.Ishl.name,new syntelos.xb.op.Ishl(true));
        dict.put(syntelos.xb.op.Ishr.name,new syntelos.xb.op.Ishr(true));
        dict.put(syntelos.xb.op.Istore0.name,new syntelos.xb.op.Istore0(true));
        dict.put(syntelos.xb.op.Istore1.name,new syntelos.xb.op.Istore1(true));
        dict.put(syntelos.xb.op.Istore2.name,new syntelos.xb.op.Istore2(true));
        dict.put(syntelos.xb.op.Istore3.name,new syntelos.xb.op.Istore3(true));
        dict.put(syntelos.xb.op.Istore.name,new syntelos.xb.op.Istore(true));
        dict.put(syntelos.xb.op.Isub.name,new syntelos.xb.op.Isub(true));
        dict.put(syntelos.xb.op.Iushr.name,new syntelos.xb.op.Iushr(true));
        dict.put(syntelos.xb.op.Ixor.name,new syntelos.xb.op.Ixor(true));
        dict.put(syntelos.xb.op.JsrW.name,new syntelos.xb.op.JsrW(true));
        dict.put(syntelos.xb.op.Jsr.name,new syntelos.xb.op.Jsr(true));
        dict.put(syntelos.xb.op.L2d.name,new syntelos.xb.op.L2d(true));
        dict.put(syntelos.xb.op.L2f.name,new syntelos.xb.op.L2f(true));
        dict.put(syntelos.xb.op.L2i.name,new syntelos.xb.op.L2i(true));
        dict.put(syntelos.xb.op.Ladd.name,new syntelos.xb.op.Ladd(true));
        dict.put(syntelos.xb.op.Laload.name,new syntelos.xb.op.Laload(true));
        dict.put(syntelos.xb.op.Land.name,new syntelos.xb.op.Land(true));
        dict.put(syntelos.xb.op.Lastore.name,new syntelos.xb.op.Lastore(true));
        dict.put(syntelos.xb.op.Lcmp.name,new syntelos.xb.op.Lcmp(true));
        dict.put(syntelos.xb.op.Lconst0.name,new syntelos.xb.op.Lconst0(true));
        dict.put(syntelos.xb.op.Lconst1.name,new syntelos.xb.op.Lconst1(true));
        dict.put(syntelos.xb.op.Ldc2W.name,new syntelos.xb.op.Ldc2W(true));
        dict.put(syntelos.xb.op.LdcW.name,new syntelos.xb.op.LdcW(true));
        dict.put(syntelos.xb.op.Ldc.name,new syntelos.xb.op.Ldc(true));
        dict.put(syntelos.xb.op.Ldiv.name,new syntelos.xb.op.Ldiv(true));
        dict.put(syntelos.xb.op.Lload0.name,new syntelos.xb.op.Lload0(true));
        dict.put(syntelos.xb.op.Lload1.name,new syntelos.xb.op.Lload1(true));
        dict.put(syntelos.xb.op.Lload2.name,new syntelos.xb.op.Lload2(true));
        dict.put(syntelos.xb.op.Lload3.name,new syntelos.xb.op.Lload3(true));
        dict.put(syntelos.xb.op.Lload.name,new syntelos.xb.op.Lload(true));
        dict.put(syntelos.xb.op.Lmul.name,new syntelos.xb.op.Lmul(true));
        dict.put(syntelos.xb.op.Lneg.name,new syntelos.xb.op.Lneg(true));
        dict.put(syntelos.xb.op.Lookupswitch.name,new syntelos.xb.op.Lookupswitch(true));
        dict.put(syntelos.xb.op.Lor.name,new syntelos.xb.op.Lor(true));
        dict.put(syntelos.xb.op.Lrem.name,new syntelos.xb.op.Lrem(true));
        dict.put(syntelos.xb.op.Lreturn.name,new syntelos.xb.op.Lreturn(true));
        dict.put(syntelos.xb.op.Lshl.name,new syntelos.xb.op.Lshl(true));
        dict.put(syntelos.xb.op.Lshr.name,new syntelos.xb.op.Lshr(true));
        dict.put(syntelos.xb.op.Lstore0.name,new syntelos.xb.op.Lstore0(true));
        dict.put(syntelos.xb.op.Lstore1.name,new syntelos.xb.op.Lstore1(true));
        dict.put(syntelos.xb.op.Lstore2.name,new syntelos.xb.op.Lstore2(true));
        dict.put(syntelos.xb.op.Lstore3.name,new syntelos.xb.op.Lstore3(true));
        dict.put(syntelos.xb.op.Lstore.name,new syntelos.xb.op.Lstore(true));
        dict.put(syntelos.xb.op.Lsub.name,new syntelos.xb.op.Lsub(true));
        dict.put(syntelos.xb.op.Lushr.name,new syntelos.xb.op.Lushr(true));
        dict.put(syntelos.xb.op.Lxor.name,new syntelos.xb.op.Lxor(true));
        dict.put(syntelos.xb.op.Monitorenter.name,new syntelos.xb.op.Monitorenter(true));
        dict.put(syntelos.xb.op.Monitorexit.name,new syntelos.xb.op.Monitorexit(true));
        dict.put(syntelos.xb.op.Multianewarray.name,new syntelos.xb.op.Multianewarray(true));
        dict.put(syntelos.xb.op.Newarray.name,new syntelos.xb.op.Newarray(true));
        dict.put(syntelos.xb.op.New.name,new syntelos.xb.op.New(true));
        dict.put(syntelos.xb.op.Nop.name,new syntelos.xb.op.Nop(true));
        dict.put(syntelos.xb.op.Pop2.name,new syntelos.xb.op.Pop2(true));
        dict.put(syntelos.xb.op.Pop.name,new syntelos.xb.op.Pop(true));
        dict.put(syntelos.xb.op.Putfield.name,new syntelos.xb.op.Putfield(true));
        dict.put(syntelos.xb.op.Putstatic.name,new syntelos.xb.op.Putstatic(true));
        dict.put(syntelos.xb.op.Return.name,new syntelos.xb.op.Return(true));
        dict.put(syntelos.xb.op.Ret.name,new syntelos.xb.op.Ret(true));
        dict.put(syntelos.xb.op.Saload.name,new syntelos.xb.op.Saload(true));
        dict.put(syntelos.xb.op.Sastore.name,new syntelos.xb.op.Sastore(true));
        dict.put(syntelos.xb.op.Sipush.name,new syntelos.xb.op.Sipush(true));
        dict.put(syntelos.xb.op.Swap.name,new syntelos.xb.op.Swap(true));
        dict.put(syntelos.xb.op.Tableswitch.name,new syntelos.xb.op.Tableswitch(true));
        dict.put(syntelos.xb.op.Wide.name,new syntelos.xb.op.Wide(true));

    }
    public final static int FromString(java.lang.String name){
        Op re = (Op)dict.get(name);
        if (null == re)
            return -1;
        else
            return re.getCode();
    }
    public final static Op New(int code){
        java.lang.String name = ToString(code);
        if (null == name)
            return null;
        else {
            Op shared = (Op)dict.get(name);
            if (null == shared)
                return null;
            else
                return shared.cloneOp();
        }
    }
    public final static Op New(int code, org.w3c.dom.Document doc){
        java.lang.String name = ToString(code);
        if (null == name)
            return null;
        else {
            Op shared = (Op)dict.get(name);
            if (null == shared)
                return null;
            else {
                Op re = shared.cloneOp();
                re.resetOwnerDocument(doc);
                return re;
            }
        }
    }

    public final static Op New(java.lang.String name){
        Op re = (Op)dict.get(name);
        if (null == re)
            return null;
        else
            return re.cloneOp();
    }
    public final static Op New(java.lang.String name, org.w3c.dom.Document doc){
        Op re = (Op)dict.get(name);
        if (null == re)
            return null;
        else {
            re = re.cloneOp();
            re.resetOwnerDocument(doc);
            return re;
        }
    }

    public final static java.lang.String ToString(int code){
        switch(code){
        case CODE_NOP:
            return syntelos.xb.op.Nop.name;
        case CODE_ACONST_NULL:
            return syntelos.xb.op.AconstNull.name;
        case CODE_ICONST_M1:
            return syntelos.xb.op.IconstM1.name;
        case CODE_ICONST_0:
            return syntelos.xb.op.Iconst0.name;
        case CODE_ICONST_1:
            return syntelos.xb.op.Iconst1.name;
        case CODE_ICONST_2:
            return syntelos.xb.op.Iconst2.name;
        case CODE_ICONST_3:
            return syntelos.xb.op.Iconst3.name;
        case CODE_ICONST_4:
            return syntelos.xb.op.Iconst4.name;
        case CODE_ICONST_5:
            return syntelos.xb.op.Iconst5.name;
        case CODE_LCONST_0:
            return syntelos.xb.op.Lconst0.name;
        case CODE_LCONST_1:
            return syntelos.xb.op.Lconst1.name;
        case CODE_FCONST_0:
            return syntelos.xb.op.Fconst0.name;
        case CODE_FCONST_1:
            return syntelos.xb.op.Fconst1.name;
        case CODE_FCONST_2:
            return syntelos.xb.op.Fconst2.name;
        case CODE_DCONST_0:
            return syntelos.xb.op.Dconst0.name;
        case CODE_DCONST_1:
            return syntelos.xb.op.Dconst1.name;
        case CODE_BIPUSH:
            return syntelos.xb.op.Bipush.name;
        case CODE_SIPUSH:
            return syntelos.xb.op.Sipush.name;
        case CODE_LDC:
            return syntelos.xb.op.Ldc.name;
        case CODE_LDC_W:
            return syntelos.xb.op.LdcW.name;
        case CODE_LDC2_W:
            return syntelos.xb.op.Ldc2W.name;
        case CODE_ILOAD:
            return syntelos.xb.op.Iload.name;
        case CODE_LLOAD:
            return syntelos.xb.op.Lload.name;
        case CODE_FLOAD:
            return syntelos.xb.op.Fload.name;
        case CODE_DLOAD:
            return syntelos.xb.op.Dload.name;
        case CODE_ALOAD:
            return syntelos.xb.op.Aload.name;
        case CODE_ILOAD_0:
            return syntelos.xb.op.Iload0.name;
        case CODE_ILOAD_1:
            return syntelos.xb.op.Iload1.name;
        case CODE_ILOAD_2:
            return syntelos.xb.op.Iload2.name;
        case CODE_ILOAD_3:
            return syntelos.xb.op.Iload3.name;
        case CODE_LLOAD_0:
            return syntelos.xb.op.Lload0.name;
        case CODE_LLOAD_1:
            return syntelos.xb.op.Lload1.name;
        case CODE_LLOAD_2:
            return syntelos.xb.op.Lload2.name;
        case CODE_LLOAD_3:
            return syntelos.xb.op.Lload3.name;
        case CODE_FLOAD_0:
            return syntelos.xb.op.Fload0.name;
        case CODE_FLOAD_1:
            return syntelos.xb.op.Fload1.name;
        case CODE_FLOAD_2:
            return syntelos.xb.op.Fload2.name;
        case CODE_FLOAD_3:
            return syntelos.xb.op.Fload3.name;
        case CODE_DLOAD_0:
            return syntelos.xb.op.Dload0.name;
        case CODE_DLOAD_1:
            return syntelos.xb.op.Dload1.name;
        case CODE_DLOAD_2:
            return syntelos.xb.op.Dload2.name;
        case CODE_DLOAD_3:
            return syntelos.xb.op.Dload3.name;
        case CODE_ALOAD_0:
            return syntelos.xb.op.Aload0.name;
        case CODE_ALOAD_1:
            return syntelos.xb.op.Aload1.name;
        case CODE_ALOAD_2:
            return syntelos.xb.op.Aload2.name;
        case CODE_ALOAD_3:
            return syntelos.xb.op.Aload3.name;
        case CODE_IALOAD:
            return syntelos.xb.op.Iaload.name;
        case CODE_LALOAD:
            return syntelos.xb.op.Laload.name;
        case CODE_FALOAD:
            return syntelos.xb.op.Faload.name;
        case CODE_DALOAD:
            return syntelos.xb.op.Daload.name;
        case CODE_AALOAD:
            return syntelos.xb.op.Aaload.name;
        case CODE_BALOAD:
            return syntelos.xb.op.Baload.name;
        case CODE_CALOAD:
            return syntelos.xb.op.Caload.name;
        case CODE_SALOAD:
            return syntelos.xb.op.Saload.name;
        case CODE_ISTORE:
            return syntelos.xb.op.Istore.name;
        case CODE_LSTORE:
            return syntelos.xb.op.Lstore.name;
        case CODE_FSTORE:
            return syntelos.xb.op.Fstore.name;
        case CODE_DSTORE:
            return syntelos.xb.op.Dstore.name;
        case CODE_ASTORE:
            return syntelos.xb.op.Astore.name;
        case CODE_ISTORE_0:
            return syntelos.xb.op.Istore0.name;
        case CODE_ISTORE_1:
            return syntelos.xb.op.Istore1.name;
        case CODE_ISTORE_2:
            return syntelos.xb.op.Istore2.name;
        case CODE_ISTORE_3:
            return syntelos.xb.op.Istore3.name;
        case CODE_LSTORE_0:
            return syntelos.xb.op.Lstore0.name;
        case CODE_LSTORE_1:
            return syntelos.xb.op.Lstore1.name;
        case CODE_LSTORE_2:
            return syntelos.xb.op.Lstore2.name;
        case CODE_LSTORE_3:
            return syntelos.xb.op.Lstore3.name;
        case CODE_FSTORE_0:
            return syntelos.xb.op.Fstore0.name;
        case CODE_FSTORE_1:
            return syntelos.xb.op.Fstore1.name;
        case CODE_FSTORE_2:
            return syntelos.xb.op.Fstore2.name;
        case CODE_FSTORE_3:
            return syntelos.xb.op.Fstore3.name;
        case CODE_DSTORE_0:
            return syntelos.xb.op.Dstore0.name;
        case CODE_DSTORE_1:
            return syntelos.xb.op.Dstore1.name;
        case CODE_DSTORE_2:
            return syntelos.xb.op.Dstore2.name;
        case CODE_DSTORE_3:
            return syntelos.xb.op.Dstore3.name;
        case CODE_ASTORE_0:
            return syntelos.xb.op.Astore0.name;
        case CODE_ASTORE_1:
            return syntelos.xb.op.Astore1.name;
        case CODE_ASTORE_2:
            return syntelos.xb.op.Astore2.name;
        case CODE_ASTORE_3:
            return syntelos.xb.op.Astore3.name;
        case CODE_IASTORE:
            return syntelos.xb.op.Iastore.name;
        case CODE_LASTORE:
            return syntelos.xb.op.Lastore.name;
        case CODE_FASTORE:
            return syntelos.xb.op.Fastore.name;
        case CODE_DASTORE:
            return syntelos.xb.op.Dastore.name;
        case CODE_AASTORE:
            return syntelos.xb.op.Aastore.name;
        case CODE_BASTORE:
            return syntelos.xb.op.Bastore.name;
        case CODE_CASTORE:
            return syntelos.xb.op.Castore.name;
        case CODE_SASTORE:
            return syntelos.xb.op.Sastore.name;
        case CODE_POP:
            return syntelos.xb.op.Pop.name;
        case CODE_POP2:
            return syntelos.xb.op.Pop2.name;
        case CODE_DUP:
            return syntelos.xb.op.Dup.name;
        case CODE_DUP_X1:
            return syntelos.xb.op.DupX1.name;
        case CODE_DUP_X2:
            return syntelos.xb.op.DupX2.name;
        case CODE_DUP2:
            return syntelos.xb.op.Dup2.name;
        case CODE_DUP2_X1:
            return syntelos.xb.op.Dup2X1.name;
        case CODE_DUP2_X2:
            return syntelos.xb.op.Dup2X2.name;
        case CODE_SWAP:
            return syntelos.xb.op.Swap.name;
        case CODE_IADD:
            return syntelos.xb.op.Iadd.name;
        case CODE_LADD:
            return syntelos.xb.op.Ladd.name;
        case CODE_FADD:
            return syntelos.xb.op.Fadd.name;
        case CODE_DADD:
            return syntelos.xb.op.Dadd.name;
        case CODE_ISUB:
            return syntelos.xb.op.Isub.name;
        case CODE_LSUB:
            return syntelos.xb.op.Lsub.name;
        case CODE_FSUB:
            return syntelos.xb.op.Fsub.name;
        case CODE_DSUB:
            return syntelos.xb.op.Dsub.name;
        case CODE_IMUL:
            return syntelos.xb.op.Imul.name;
        case CODE_LMUL:
            return syntelos.xb.op.Lmul.name;
        case CODE_FMUL:
            return syntelos.xb.op.Fmul.name;
        case CODE_DMUL:
            return syntelos.xb.op.Dmul.name;
        case CODE_IDIV:
            return syntelos.xb.op.Idiv.name;
        case CODE_LDIV:
            return syntelos.xb.op.Ldiv.name;
        case CODE_FDIV:
            return syntelos.xb.op.Fdiv.name;
        case CODE_DDIV:
            return syntelos.xb.op.Ddiv.name;
        case CODE_IREM:
            return syntelos.xb.op.Irem.name;
        case CODE_LREM:
            return syntelos.xb.op.Lrem.name;
        case CODE_FREM:
            return syntelos.xb.op.Frem.name;
        case CODE_DREM:
            return syntelos.xb.op.Drem.name;
        case CODE_INEG:
            return syntelos.xb.op.Ineg.name;
        case CODE_LNEG:
            return syntelos.xb.op.Lneg.name;
        case CODE_FNEG:
            return syntelos.xb.op.Fneg.name;
        case CODE_DNEG:
            return syntelos.xb.op.Dneg.name;
        case CODE_ISHL:
            return syntelos.xb.op.Ishl.name;
        case CODE_LSHL:
            return syntelos.xb.op.Lshl.name;
        case CODE_ISHR:
            return syntelos.xb.op.Ishr.name;
        case CODE_LSHR:
            return syntelos.xb.op.Lshr.name;
        case CODE_IUSHR:
            return syntelos.xb.op.Iushr.name;
        case CODE_LUSHR:
            return syntelos.xb.op.Lushr.name;
        case CODE_IAND:
            return syntelos.xb.op.Iand.name;
        case CODE_LAND:
            return syntelos.xb.op.Land.name;
        case CODE_IOR:
            return syntelos.xb.op.Ior.name;
        case CODE_LOR:
            return syntelos.xb.op.Lor.name;
        case CODE_IXOR:
            return syntelos.xb.op.Ixor.name;
        case CODE_LXOR:
            return syntelos.xb.op.Lxor.name;
        case CODE_IINC:
            return syntelos.xb.op.Iinc.name;
        case CODE_I2L:
            return syntelos.xb.op.I2l.name;
        case CODE_I2F:
            return syntelos.xb.op.I2f.name;
        case CODE_I2D:
            return syntelos.xb.op.I2d.name;
        case CODE_L2I:
            return syntelos.xb.op.L2i.name;
        case CODE_L2F:
            return syntelos.xb.op.L2f.name;
        case CODE_L2D:
            return syntelos.xb.op.L2d.name;
        case CODE_F2I:
            return syntelos.xb.op.F2i.name;
        case CODE_F2L:
            return syntelos.xb.op.F2l.name;
        case CODE_F2D:
            return syntelos.xb.op.F2d.name;
        case CODE_D2I:
            return syntelos.xb.op.D2i.name;
        case CODE_D2L:
            return syntelos.xb.op.D2l.name;
        case CODE_D2F:
            return syntelos.xb.op.D2f.name;
        case CODE_I2B:
            return syntelos.xb.op.I2b.name;
        case CODE_I2C:
            return syntelos.xb.op.I2c.name;
        case CODE_I2S:
            return syntelos.xb.op.I2s.name;
        case CODE_LCMP:
            return syntelos.xb.op.Lcmp.name;
        case CODE_FCMPL:
            return syntelos.xb.op.Fcmpl.name;
        case CODE_FCMPG:
            return syntelos.xb.op.Fcmpg.name;
        case CODE_DCMPL:
            return syntelos.xb.op.Dcmpl.name;
        case CODE_DCMPG:
            return syntelos.xb.op.Dcmpg.name;
        case CODE_IFEQ:
            return syntelos.xb.op.Ifeq.name;
        case CODE_IFNE:
            return syntelos.xb.op.Ifne.name;
        case CODE_IFLT:
            return syntelos.xb.op.Iflt.name;
        case CODE_IFGE:
            return syntelos.xb.op.Ifge.name;
        case CODE_IFGT:
            return syntelos.xb.op.Ifgt.name;
        case CODE_IFLE:
            return syntelos.xb.op.Ifle.name;
        case CODE_IF_ICMPEQ:
            return syntelos.xb.op.IfIcmpeq.name;
        case CODE_IF_ICMPNE:
            return syntelos.xb.op.IfIcmpne.name;
        case CODE_IF_ICMPLT:
            return syntelos.xb.op.IfIcmplt.name;
        case CODE_IF_ICMPGE:
            return syntelos.xb.op.IfIcmpge.name;
        case CODE_IF_ICMPGT:
            return syntelos.xb.op.IfIcmpgt.name;
        case CODE_IF_ICMPLE:
            return syntelos.xb.op.IfIcmple.name;
        case CODE_IF_ACMPEQ:
            return syntelos.xb.op.IfAcmpeq.name;
        case CODE_IF_ACMPNE:
            return syntelos.xb.op.IfAcmpne.name;
        case CODE_GOTO:
            return syntelos.xb.op.Goto.name;
        case CODE_JSR:
            return syntelos.xb.op.Jsr.name;
        case CODE_RET:
            return syntelos.xb.op.Ret.name;
        case CODE_TABLESWITCH:
            return syntelos.xb.op.Tableswitch.name;
        case CODE_LOOKUPSWITCH:
            return syntelos.xb.op.Lookupswitch.name;
        case CODE_IRETURN:
            return syntelos.xb.op.Ireturn.name;
        case CODE_LRETURN:
            return syntelos.xb.op.Lreturn.name;
        case CODE_FRETURN:
            return syntelos.xb.op.Freturn.name;
        case CODE_DRETURN:
            return syntelos.xb.op.Dreturn.name;
        case CODE_ARETURN:
            return syntelos.xb.op.Areturn.name;
        case CODE_RETURN:
            return syntelos.xb.op.Return.name;
        case CODE_GETSTATIC:
            return syntelos.xb.op.Getstatic.name;
        case CODE_PUTSTATIC:
            return syntelos.xb.op.Putstatic.name;
        case CODE_GETFIELD:
            return syntelos.xb.op.Getfield.name;
        case CODE_PUTFIELD:
            return syntelos.xb.op.Putfield.name;
        case CODE_INVOKEVIRTUAL:
            return syntelos.xb.op.Invokevirtual.name;
        case CODE_INVOKESPECIAL:
            return syntelos.xb.op.Invokespecial.name;
        case CODE_INVOKESTATIC:
            return syntelos.xb.op.Invokestatic.name;
        case CODE_INVOKEINTERFACE:
            return syntelos.xb.op.Invokeinterface.name;
        case CODE_NEW:
            return syntelos.xb.op.New.name;
        case CODE_NEWARRAY:
            return syntelos.xb.op.Newarray.name;
        case CODE_ANEWARRAY:
            return syntelos.xb.op.Anewarray.name;
        case CODE_ARRAYLENGTH:
            return syntelos.xb.op.Arraylength.name;
        case CODE_ATHROW:
            return syntelos.xb.op.Athrow.name;
        case CODE_CHECKCAST:
            return syntelos.xb.op.Checkcast.name;
        case CODE_INSTANCEOF:
            return syntelos.xb.op.Instanceof.name;
        case CODE_MONITORENTER:
            return syntelos.xb.op.Monitorenter.name;
        case CODE_MONITOREXIT:
            return syntelos.xb.op.Monitorexit.name;
        case CODE_WIDE:
            return syntelos.xb.op.Wide.name;
        case CODE_MULTIANEWARRAY:
            return syntelos.xb.op.Multianewarray.name;
        case CODE_IFNULL:
            return syntelos.xb.op.Ifnull.name;
        case CODE_IFNONNULL:
            return syntelos.xb.op.Ifnonnull.name;
        case CODE_GOTO_W:
            return syntelos.xb.op.GotoW.name;
        case CODE_JSR_W:
            return syntelos.xb.op.JsrW.name;
        default:
            return null;
        }
    }




    private byte[] cf;

    protected Op(org.w3c.dom.Document doc, syntelos.iou.dom.Name name){
        super(name);
        this.setShared(false);
    }
    protected Op(syntelos.iou.dom.Name name, boolean shared){
        super(name);
        this.setShared(shared);
    }

    public final syntelos.xb.op.Code getOpCode(){
        return (syntelos.xb.op.Code)this.getParentNode();
    }
    public final syntelos.xb.at.Code getAttributeCode(){
        return this.getOpCode().getAttributeCode();
    }
    public final syntelos.xb.at.LocalVariableTable getAttributeLocalVariableTable(){
        return this.getOpCode().getAttributeLocalVariableTable();
    }
    public final Method getMethod(){
        return this.getOpCode().getMethod();
    }
    public final syntelos.iou.dom.Attr getPCAttr(){
        syntelos.iou.dom.Attr attr = this.getAttributeNode2(ATTRNAME_PC.getLocalname());
        if (null == attr){
            org.w3c.dom.Document doc = this.getOwnerDocument();
            attr = new syntelos.iou.dom.impl.Attr(doc,ATTRNAME_PC);
            this.setAttributeNode(attr);
        }
        return attr;
    }
    public final syntelos.iou.dom.Attr getLnoAttr(){
        syntelos.iou.dom.Attr attr = this.getAttributeNode2(ATTRNAME_LNO.getLocalname());
        if (null == attr){
            org.w3c.dom.Document doc = this.getOwnerDocument();
            attr = new syntelos.iou.dom.impl.Attr(doc,ATTRNAME_LNO);
            this.setAttributeNode(attr);
        }
        return attr;
    }
    public abstract int getCode();

    public abstract java.lang.String getName();

    /**
     * @return Number of bytes following opcode in an instruction
     * stream --- may depend on the instruction having a valid
     * internal state (field values, eg, PC)
     */
    public abstract int sizeOperands();

    /**
     * @return Zero (0) for no logical byte code operands, negative
     * one (-1) for a variable number of logical operands, or a
     * positive number of logical operands (typically one or two).
     * @see #sizeOperands()
     */
    public int countOperands(){
        return 0;
    }

    public abstract int countStackPop();

    public abstract int countStackPush();

    /**
     * Read operands following byte opcode for this instruction
     */
    public abstract void readCF(syntelos.xb.Class clas, Method meth, Op.Reader in)
        throws java.io.IOException;

    /**
     * Write byte opcode and operands for this instruction
     */
    public abstract void writeCF(syntelos.xb.Class clas, Method meth, Op.Writer out)
        throws java.io.IOException;

    public void readCF(IO.Uri src, CF.Reader reader)
        throws java.io.IOException
    {
        throw new Error.Bug();	// Driven by syntelos.xb.op.Code
    }

    public void writeCF(IO.Uri dst, CF.Writer writer)
        throws java.io.IOException
    {
        throw new Error.Bug();	// Driven by syntelos.xb.op.Code
    }
    
    public Op cloneOp(){
        Op clone = (Op)super.cloneNode(false);
        clone.setShared(false);
        return clone;
    }
    /**
     * @return Instruction byte code offset, value of attribute PC
     */
    public final int getPC(){
        syntelos.iou.dom.Attr attr = this.getPCAttr();
        java.lang.Integer number = (java.lang.Integer)attr.getData(IO.Data.INTEGER,this);
        if (null != number)
            return number.intValue();
        else
            throw new Error.State("Missing operand 'pc'.");
    }
    public final int getPC(int defval){
        syntelos.iou.dom.Attr attr = this.getPCAttr();
        java.lang.Integer number = (java.lang.Integer)attr.getData(IO.Data.INTEGER,this);
        if (null != number)
            return number.intValue();
        else
            return defval;
    }
    public final boolean setPC(Op.Reader reader){
        if (this.isSharedNot()){

            this.setPC(reader.offset());

            return (-1 < this.getPC());
        }
        else
            throw new Error.Bug();
    }
    public final boolean setPC(Op.Writer writer)
        throws java.io.IOException
    {
        if (this.isSharedNot()){

            writer.write(this.getCode());

            this.setPC(writer.offset());

            return (-1 < this.getPC());
        }
        else
            throw new Error.Bug();
    }
    /**
     * @param Set attr PC
     */
    public final void setPC(int value){
        if (this.isSharedNot()){
            syntelos.iou.dom.Attr attr = this.getPCAttr();
            java.lang.Integer number = new java.lang.Integer(value);
            attr.setData(number,this);
        }
        else
            throw new Error.Bug();
    }
    /**
     * @return Get attr LNO
     */
    public final int getLine(){
        syntelos.iou.dom.Attr attr = this.getLnoAttr();
        java.lang.Integer number = (java.lang.Integer)attr.getData(IO.Data.INTEGER,this);
        if (null != number)
            return number.intValue();
        else
            return 0;
    }
    /**
     * @param Set attr LNO
     */
    public final void setLine(int value){
        if (this.isSharedNot()){
            syntelos.iou.dom.Attr attr = this.getLnoAttr();
            java.lang.Integer number = new java.lang.Integer(value);
            attr.setData(number,this);
        }
        else
            throw new Error.Bug();
    }
    /**
     * @return Get attr ID
     */
    public final int getIndex(){
        syntelos.iou.dom.Attr attr = this.getIdAttr();
        java.lang.Integer number = (java.lang.Integer)attr.getData(IO.Data.INTEGER,this);
        if (null != number)
            return number.intValue();
        else
            throw new Error.State("Missing operand 'id'.");
    }
    /**
     * @param value Set attr ID
     */
    public final void setIndex(int value){
        if (this.isSharedNot()){
            syntelos.iou.dom.Attr attr = this.getIdAttr();
            java.lang.Integer number = new java.lang.Integer(value);
            attr.setData(number,this);
        }
        else
            throw new Error.Bug();
    }
    protected byte[] getCF(){
        byte[] re = this.cf;
        if (null == re){
            int len = this.sizeOperands();
            if (-1 < len)
                return (this.cf = new byte[len]);
            else
                return null;
        }
        else
            return re;
    }
    protected byte[] getCF(int len){
        byte[] re = this.cf;
        if (null == re){
            if (-1 < len)
                return (this.cf = new byte[len]);
            else
                return null;
        }
        else {
            int re_len = re.length;
            if (len == re_len)
                return re;
            else {
                byte[] copier = new byte[len];
                if (len < re_len)
                    java.lang.System.arraycopy(re,0,copier,0,len);
                else
                    java.lang.System.arraycopy(re,0,copier,0,re_len);
                return (this.cf = copier);
            }
        }
    }
    /**
     * @param idx Byte offset into CF operands data
     * @return Sign extended one byte integer
     */
    protected int getCFIntS1(int idx){
        byte[] re = this.cf;
        if (null != re && -1 < idx && idx < re.length)
            return re[idx];
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * @param idx Byte offset into CF operands data
     * @return Unsigned one byte integer
     */
    protected int getCFIntU1(int idx){
        byte[] re = this.cf;
        if (null != re && -1 < idx && idx < re.length)
            return (re[idx] & 0xff);
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * @param idx Byte offset into CF operands data
     * @return Sign extended two byte integer
     */
    protected int getCFIntS2(int idx){
        byte[] re = this.cf;
        int bi2 = (idx * 2);
        if (null != re && -1 < bi2 && (bi2+1) < re.length){
            int acc = re[bi2];
            acc <<= 8;
            acc += (re[bi2+1] & 0xff);
            return acc;
        }
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * @param idx Byte offset into CF operands data
     * @return Unsigned extended two byte integer
     */
    protected int getCFIntU2(int idx){
        byte[] re = this.cf;
        int bi2 = (idx * 2);
        if (null != re && -1 < bi2 && (bi2+1) < re.length){
            int acc;
            acc = ((re[bi2+0] & 0xff) << 8);
            acc += (re[bi2+1] & 0xff);
            return acc;
        }
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * @param idx Byte offset into CF operands data
     * @return Four bytes packed to integer
     */
    protected int getCFIntS4(int idx){
        byte[] re = this.cf;
        int bi4 = (idx * 4);
        if (null != re && -1 < bi4 && (bi4+3) < re.length){
            int acc;
            acc  = (re[bi4  ] & 0xff) << 24;
            acc += (re[bi4+1] & 0xff) << 16;
            acc += (re[bi4+2] & 0xff) << 8;
            acc += (re[bi4+3] & 0xff);
            return acc;
        }
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    protected void setCF(byte[] cf){
        if (this.isSharedNot())
            this.cf = cf;
        else
            throw new Error.Bug();
    }
    /**
     * @param idx Byte offset into CF operands data
     * @param value Signed one byte integer
     */
    protected void setCFIntS1(int idx, int value){
        byte[] cf = this.cf;
        if (null != cf && -1 < idx && idx < cf.length)
            cf[idx] = (byte)value;
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * @param idx Byte offset into CF operands data
     * @param value Unsigned one byte integer
     */
    protected void setCFIntU1(int idx, int value){
        byte[] cf = this.cf;
        if (null != cf && -1 < idx && idx < cf.length)
            cf[idx] = (byte)(value & 0xff);
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * @param idx Byte offset into CF operands data
     * @param value Signed two byte integer
     */
    protected void setCFIntS2(int idx, int value){
        byte[] cf = this.cf;
        int bi2 = (idx * 2);
        if (null != cf && -1 < bi2 && (bi2+1) < cf.length){
            cf[bi2  ] = (byte)((value >> 8) & 0xff);
            cf[bi2+1] = (byte)((value     ) & 0xff);
        }
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * @param idx Byte offset into CF operands data
     * @param value Unsigned two byte integer
     */
    protected void setCFIntU2(int idx, int value){
        byte[] cf = this.cf;
        int bi2 = (idx * 2);
        if (null != cf && -1 < bi2 && (bi2+1) < cf.length){
            cf[bi2  ] = (byte)((value >>> 8) & 0xff);
            cf[bi2+1] = (byte)((value      ) & 0xff);
        }
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * @param idx Byte offset into CF operands data
     * @param value Unsigned four byte integer
     */
    protected void setCFIntS4(int idx, int value){
        byte[] cf = this.cf;
        int bi4 = (idx * 2);
        if (null != cf && -1 < bi4 && (bi4+3) < cf.length){
            cf[bi4  ] = (byte)((value >>> 24) & 0xff);
            cf[bi4+1] = (byte)((value >>> 16) & 0xff);
            cf[bi4+2] = (byte)((value >>>  8) & 0xff);
            cf[bi4+3] = (byte)((value       ) & 0xff);
        }
        else
            throw new IllegalArgumentException(java.lang.String.valueOf(idx));
    }
    /**
     * <p> Switch padding used by {@link
     * syntelos.xb.op.Tableswitch tableswitch} and {@link
     * syntelos.xb.op.Lookupswitch lookupswitch}. </p>
     * 
     * @param pc Instruction's operator code value offset (in bytes)
     * in the {@link syntelos.xb.op.Code op.code} (sub) stream
     * @return Operand for stream skip for the 32bit alignment of the
     * next word (switch case "default" jump offset value)
     * 
     * @see syntelos.xb.op.Tableswitch
     * @see syntelos.xb.op.Lookupswitch
     */
    protected final static int Pad(int pc){

        return ((pc ^ 3) & 3);
    }

    /**
     * This instruction has a JCF (byte code) operand of one, two of
     * four bytes.  Note that switch pads are not operands. </p>
     * 
     * @see syntelos.xb.Op$Constant
     * @see syntelos.xb.Op$Variable
     * @see syntelos.xb.Op$Branch
     * @see syntelos.xb.op.Bipush
     * @see syntelos.xb.op.Sipush
     */
    public abstract static class Operand
        extends Op
    {

        protected Operand(org.w3c.dom.Document doc, syntelos.iou.dom.Name type){
            super(doc,type);
        }
        protected Operand(syntelos.iou.dom.Name type, boolean shared){
            super(type,shared);
        }

        public int countOperands(){
            return 1;
        }
        public int getOperand(){
            java.lang.Integer number = (java.lang.Integer)this.getChildData(IO.Data.INTEGER,this);
            if (null != number)
                return number.intValue();
            else
                throw new Error.State("Missing operand.");
        }
        public void setOperand(int value){
            java.lang.Integer number = new java.lang.Integer(value);
            this.setChildData(number,this);
        }

    }
    /**
     * <p> The first JCF (byte code) operand of this instruction is
     * an index into the {@link ConstantPool}. </p>
     * 
     * @see syntelos.xb.op.Ldc
     * @see syntelos.xb.op.LdcW
     * @see syntelos.xb.op.Ldc2W
     */
    public abstract static class Constant
        extends Operand
    {
        protected Constant(org.w3c.dom.Document doc, syntelos.iou.dom.Name type){
            super(doc,type);
        }
        protected Constant(syntelos.iou.dom.Name type, boolean shared){
            super(type,shared);
        }

        public syntelos.iou.dom.Node decompile(){
            this.getOperandConst();
            return this;
        }
        public syntelos.iou.dom.Node compile(){
            this.getOperandConst();
            return this;
        }
        public CF.Constants.Const getOperandConst(){
            return (CF.Constants.Const)this.getChildData(IO.Data.CONST,this);
        }
        public int getOperand(){
            CF.Constants.Const constant = this.getOperandConst();
            return constant.getIndex();
        }
        public void setOperand(CF.Constants.Const cc){
            this.setChildData(cc,this);
        }
    }
    /**
     * <p> The first JCF (byte code) operand of this instruction is an
     * index into the {@link syntelos.xb.at.LocalVariableTable} of
     * the {@link Method} {@link syntelos.xb.at.Code}. </p>
     * 
     * @see syntelos.xb.op.Iload
     * @see syntelos.xb.op.Lload
     * @see syntelos.xb.op.Fload
     * @see syntelos.xb.op.Dload
     * @see syntelos.xb.op.Aload
     * @see syntelos.xb.op.Istore
     * @see syntelos.xb.op.Lstore
     * @see syntelos.xb.op.Fstore
     * @see syntelos.xb.op.Dstore
     * @see syntelos.xb.op.Astore
     * @see syntelos.xb.op.Iinc
     * @see syntelos.xb.op.Ret
     */
    public abstract static class Variable
        extends Operand
    {
        protected Variable(org.w3c.dom.Document doc, syntelos.iou.dom.Name type){
            super(doc,type);
        }
        protected Variable(syntelos.iou.dom.Name type, boolean shared){
            super(type,shared);
        }

        public syntelos.iou.dom.Node decompile(){
            this.getOperandVar();
            return this;
        }
        public syntelos.iou.dom.Node compile(){
            this.getOperandVar();
            return this;
        }
        public syntelos.xb.at.Variable getOperandVar(){

            return (syntelos.xb.at.Variable)this.getChildData(IO.Data.VAR,this);
        }
        public int getOperand(){
            syntelos.xb.at.Variable var = this.getOperandVar();
            return var.getSlotValue();
        }
        public void setOperand(syntelos.xb.at.Variable var){

            var.compileUser(this);

            this.setChildData(var,this);
        }
    }
    /**
     * <p> The first JCF (byte code) operand of this instruction is a
     * PC offset within the local {@link Method} {@link
     * syntelos.xb.at.Code code} for a branch (or jump)
     * instruction. </p>
     * 
     * <p> We can call a jump by the name branch, as on a higher level
     * of abstraction --- conceptually --- a jump is used to implement
     * branching. </p>
     *
     * @see syntelos.xb.Op$Switch
     * @see syntelos.xb.op.Ifeq
     * @see syntelos.xb.op.Ifne
     * @see syntelos.xb.op.Iflt
     * @see syntelos.xb.op.Ifge
     * @see syntelos.xb.op.Ifgt
     * @see syntelos.xb.op.Ifle
     * @see syntelos.xb.op.IfIcmpeq
     * @see syntelos.xb.op.IfIcmpne
     * @see syntelos.xb.op.IfIcmplt
     * @see syntelos.xb.op.IfIcmpge
     * @see syntelos.xb.op.IfIcmpgt
     * @see syntelos.xb.op.IfIcmple
     * @see syntelos.xb.op.IfAcmpeq
     * @see syntelos.xb.op.IfAcmpne
     * @see syntelos.xb.op.Goto
     * @see syntelos.xb.op.Jsr
     */
    public abstract static class Branch
        extends Operand
    {
        protected Branch(org.w3c.dom.Document doc, syntelos.iou.dom.Name type){
            super(doc,type);
        }
        protected Branch(syntelos.iou.dom.Name type, boolean shared){
            super(type,shared);
        }

        public syntelos.iou.dom.Node decompile(){
            this.getOperandOp();
            return this;
        }
        public syntelos.iou.dom.Node compile(){
            this.getOperandOp();
            return this;
        }
        public final int getOperand(){
            int pc = this.getPC();
            Op target = this.getOperandOp();
            if (null != target){
                int offset = target.getPC();
                return (offset - pc);
            }
            else {
                String operand = this.getChildText();
                throw new Error.Format(this,operand);
            }
        }
        public final void setOperand(int value){
            int pc = this.getPC();
            int offset = (pc + value);
            super.setOperand(offset);
        }
        public Op getOperandOp(){
            return (syntelos.xb.Op)this.getChildData(IO.Data.OP,this);
        }
        public void setOperand(Op op){
            this.setChildData(op,this);
        }
    }
    /**
     * <p> This class will be found in one of {@link
     * syntelos.xb.op.Tableswitch} or {@link
     * syntelos.xb.op.Lookupswitch}.  The first byte code operand
     * is the default case PC offset. </p>
     * 
     * <p> Note that all switches have default cases. </p>
     * 
     * @see syntelos.xb.op.Tableswitch
     * @see syntelos.xb.op.Lookupswitch
     */
    public abstract static class Switch
        extends Branch
    {
        /**
         * <p> Switch default case is an attribute of the switch
         * element. </p>
         */
        public final static class Default
            extends syntelos.xb.Base.Attribute.Operand
        {
            public final static syntelos.iou.dom.Name NAME = new syntelos.iou.dom.impl.Name(ATTRIBUTE_NODE,"http://www.syntelos.org/xb","xb:op.switch.default");

            public Default(org.w3c.dom.Document doc, syntelos.iou.dom.Name type){
                super(doc,type);
            }
            public Default(org.w3c.dom.Document doc){
                this(doc,NAME);
            }
            public Default(){
                this(DOC_NIL);
            }

            protected Switch getParentSwitch(){
                return (Switch)this.getParentNode();
            }
            public syntelos.xb.at.LocalVariableTable getAttributeLocalVariableTable(){
                return this.getParentSwitch().getAttributeLocalVariableTable();
            }
            public syntelos.xb.at.Code getAttributeCode(){
                return this.getParentSwitch().getAttributeCode();
            }
            public syntelos.xb.op.Code getOpCode(){
                return this.getParentSwitch().getOpCode();
            }
            public syntelos.iou.dom.Node decompile(){
                this.getOperandOp();
                return this;
            }
            public syntelos.iou.dom.Node compile(){
                this.getOperandOp();
                return this;
            }
            public final int getOperand(){
                java.lang.Integer number = (java.lang.Integer)this.getData(syntelos.xb.IO.Data.INTEGER,this);
                if (null != number){
                    int pc = this.getParentSwitch().getPC();
                    int offset = number.intValue();
                    return (offset - pc);
                }
                else
                    throw new syntelos.xb.Error.State("Missing operand.");
            }
            public final void setOperand(int value){
                int pc = this.getParentSwitch().getPC();
                int offset = (pc + value);
                java.lang.Integer number = new java.lang.Integer(offset);
                this.setData(number,this);
            }
            public final syntelos.xb.Op getOperandOp(){
                return (syntelos.xb.Op)this.getData(syntelos.xb.IO.Data.OP,this);
            }
            public void setOperand(syntelos.xb.Op op){
                this.setData(op,this);
            }
            public void readCF(syntelos.xb.Op.Reader in)
                throws java.io.IOException
            {
                this.setOperand(in.readInt());
            }
            public void writeCF(syntelos.iou.bbuf out)
            {
                out.write4(this.getOperand());
            }
            public void readCF(IO.Uri src, CF.Reader reader)
                throws java.io.IOException
            {
                throw new Error.Bug();	// Driven by syntelos.xb.op.Code
            }
            public void writeCF(IO.Uri dst, CF.Writer writer)
                throws java.io.IOException
            {
                throw new Error.Bug();	// Driven by syntelos.xb.op.Code
            }
        }


        protected Switch(org.w3c.dom.Document doc, syntelos.iou.dom.Name type){
            super(doc,type);
        }
        protected Switch(syntelos.iou.dom.Name type, boolean shared){
            super(type,shared);
        }

        public int countOperands(){
            return -1;
        }
        public final Default getOperandCaseDefaultAttr(){
            return (Default)this.getCreateAttributeNode(Default.NAME);
        }
        /**
         * @return Default code offset (PC) relative to the PC of the
         * operator immediately following this switch.  Default
         * class init value is zero, which is also a valid value for
         * this field.
         */
        public final int getOperandCaseDefault(){
            Default node = this.getOperandCaseDefaultAttr();
            return node.getOperand();
        }
        /**
         * @param pc Switch case 'default' code offset 
         */
        public final void setOperandCaseDefault(int pc){
            Default node = this.getOperandCaseDefaultAttr();
            node.setOperand(pc);
        }
        /**
         * @param code Op container
         * @param op The relative offset is calculated as (op.pc -
         * this.pc - this.size-operands)
         */
        public final void setOperandCaseDefault(syntelos.xb.Op op){

            Default node = this.getOperandCaseDefaultAttr();
            node.setOperand(op);
        }
        /**
         * @param key Switch case key value
         * @return Code offset 
         */
        public final int getOperandCase(int key){
            syntelos.xb.op.Operand.Case switchcase = this.getOperandCaseNode(key);
            if (null == switchcase)
                throw new syntelos.xb.Error.Argument(java.lang.String.valueOf(key));
            else
                return switchcase.getOperand();
        }
        /**
         * <p> The table switch is a special case in comparison with
         * the lookup switch.  In this case each new key must be
         * contiguous (delta +/- 1) with any existing.  </p>
         * 
         * @param key Switch case key value
         * @param pc Code offset 
         */
        public final void setOperandCase(int key, int pc){

            syntelos.xb.op.Operand.Case switchcase = this.getCreateOperandCaseNode(key);
            switchcase.setOperand(pc);
        }
        public abstract syntelos.xb.op.Operand.Case getOperandCaseNode(int key);

        public abstract syntelos.xb.op.Operand.Case getCreateOperandCaseNode(int key);
        /**
         * <p> The table switch is a special case in comparison with
         * the lookup switch.  In this case each new key must be
         * contiguous (delta +/- 1) with any existing.  </p>
         * 
         * @param code Op container
         * @param op Operator instruction
         */
        public final void setOperandCase(int key, syntelos.xb.Op op){

            syntelos.xb.op.Operand.Case switchcase = this.getCreateOperandCaseNode(key);
            switchcase.setOperand(op);
        }
    }

    public java.lang.String toString(){
        syntelos.iou.chbuf strbuf = new syntelos.iou.chbuf();
        strbuf.append("op:");
        int pc = this.getPC(-1);
        if (-1 < pc)
            strbuf.append(pc);
        else {
            java.lang.String id = this.getAttribute("id");
            if (null != id)
                strbuf.append(id);
            else
                throw new Error.State("Require one of 'pc' or 'id'.");
        }
        strbuf.append("?name=");
        strbuf.append(this.getName());
        return strbuf.toString();
    }
    public int hashCode(){
        return this.getName().hashCode();
    }
    public boolean equals(java.lang.Object another){
        return (another == this)||(null != another && this.getName().equals(another.toString()));
    }
}
